﻿using System;
using System.Threading;
using System.Collections.Generic;
using System.Linq;

namespace puerto_serie
{
    public class JugadorCpu
    {
        private Tablero TableroCpu_;
        private int UltimaPosicionDisparoX, UltimaPosicionDisparoY;
        private int[,] TableroDeJugadorVistoPorCpu_; 
        private bool golpeoEnTurnoAnterior;
        private int TAMANOMAXMO = 8;
        private int resultadoDisparo;
        private InteligenciaCpu thinker;
        public JugadorCpu(Tablero TableroCpu)
        {
            golpeoEnTurnoAnterior = false;
            resultadoDisparo = 0;
            this.TableroCpu_ = TableroCpu;
            TableroDeJugadorVistoPorCpu_ = new int[TAMANOMAXMO, TAMANOMAXMO];
            thinker = new InteligenciaCpu();
        }
        public void IniciarPosicionesCpu()
        {
            while (TableroCpu_.obtenerCantidadDeBarcosInsertados() < 5)
            {
                Random random = new Random();
                int tamañoBarcoAInsertar = TableroCpu_.obtenerCantidadDeBarcosInsertados();
                UltimaPosicionDisparoX = random.Next(TAMANOMAXMO - tamañoBarcoAInsertar);
                UltimaPosicionDisparoY = random.Next(TAMANOMAXMO - tamañoBarcoAInsertar);
                int direccion = random.Next(1000)/500;
                TableroCpu_.establishShip(direccion, UltimaPosicionDisparoX, UltimaPosicionDisparoY);
                Thread.Sleep(50);
            }
        }
        public int RealizarJugada(Tablero tableroJugador)
        {
            
            if (golpeoEnTurnoAnterior)
            {
                golpeoEnTurnoAnterior= thinker.ProcesarJugada(tableroJugador, TableroDeJugadorVistoPorCpu_,this);
                UltimaPosicionDisparoX = thinker.modificarObtenerPosicionXExtremoB;
                UltimaPosicionDisparoY = thinker.modificarObtenerPosicionYExtremoB;
                resultadoDisparo = thinker.obtenerResultado();
            }
            else
            {
                obtenerPosicionAleatoria(tableroJugador,0);
            }
            return resultadoDisparo;
        }
        private void obtenerPosicionAleatoria(Tablero tableroJugador, int contador)
        {
            int posicionY;
            int posicionX;
            if (contador < 8)
            {
                Random random = new Random();
                posicionY = random.Next(TAMANOMAXMO);
                posicionX = random.Next(TAMANOMAXMO);
                resultadoDisparo = tableroJugador.shoot(posicionX, posicionY);
                if (TableroDeJugadorVistoPorCpu_[posicionY, posicionX] != 0)
                {
                    obtenerPosicionAleatoria(tableroJugador, contador + 1);
                }
                else
                {
                    hacerCambiosPorDisparoEjecutado(posicionX, posicionY);
                }
            }
            else
            {
                bool seRealizoCambio = false;
                for (int y = 0; y < TAMANOMAXMO; y++)
                {
                    if (seRealizoCambio == false)
                    {
                        for (int x = 0; x < TAMANOMAXMO; x++)
                        {
                            if (TableroDeJugadorVistoPorCpu_[y, x] == 0)
                            {
                                resultadoDisparo = tableroJugador.shoot(x, y);
                                hacerCambiosPorDisparoEjecutado(x, y);
                                seRealizoCambio = true;
                                break;
                            }
                        }
                    }
                    else
                    {
                        break;
                    }
                }                                    
            }
        }
        public bool cambiarResultadoTurno
        {
            get
            {
                return golpeoEnTurnoAnterior;
            }
            set
            {
                golpeoEnTurnoAnterior = value;
            }
        }
        private void hacerCambiosPorDisparoEjecutado(int posicionX,int posicionY)
        {
            if (resultadoDisparo == 3)
            {
                golpeoEnTurnoAnterior = true;
                TableroDeJugadorVistoPorCpu_[posicionY, posicionX] = resultadoDisparo;
                UltimaPosicionDisparoX = posicionX;
                UltimaPosicionDisparoY = posicionY;
                thinker.golpeoEnTurnoActual = true;
                thinker.modificarObtenerPosicionXExtremoA = posicionX;
                thinker.modificarObtenerPosicionXExtremoB = posicionX;
                thinker.modificarObtenerPosicionYExtremoA = posicionY;
                thinker.modificarObtenerPosicionYExtremoB = posicionY;
                thinker.cantidadDeAciertos = 1;
                thinker.cantidadRegresiones = 0;
            }
            else
            {
                UltimaPosicionDisparoX = posicionX;
                UltimaPosicionDisparoY = posicionY;
                golpeoEnTurnoAnterior = false;
                TableroDeJugadorVistoPorCpu_[posicionY, posicionX] = resultadoDisparo;
            }
        }
        public int obtenerUltimaPosicionXDisparada()
        {
            return UltimaPosicionDisparoX;
        }
        public int obtenerUltimaPosicionYDisparada()
        {
            return UltimaPosicionDisparoY;
        }
    }
}
